home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / putz / putzlist.i < prev    next >
Text File  |  1997-10-26  |  13KB  |  435 lines
  1. IMPLEMENTATION MODULE PutzList;
  2.  
  3. FROM SYSTEM IMPORT ADDRESS, ADR, CADR, TSIZE, BYTE, ASSEMBLER, CALLSYS;
  4.  
  5. IMPORT Strings;
  6. FROM StrConv            IMPORT  LNumToStr, NumToStr, StrToCard, CardToStr,
  7.                                 StrToLInt;
  8.  
  9.  
  10. IMPORT MagicStrings;
  11.  
  12.  
  13. (* CATPUTZ-Module *)
  14. FROM PutzTypes          IMPORT grListEntry, ptrGrEntry, defaultOpts, delState,
  15.                                totalEntry, putzList, TextJustification,
  16.                                ptrDispEntry, listEntryType, MaxStr;
  17.  
  18. (* CAT-Module *)
  19.  
  20. IMPORT ConfVars;
  21. FROM Void IMPORT v;
  22.  
  23. CONST 
  24.       maxParts  = 20;                           (* Anzahl der maximalen verschiedenen Zeilenteile *)
  25.       partFormatLength = 32;                    (* maximale L„nge eines Formatstrings *)
  26.  
  27. CONST
  28.     cTotal      = "Gesamt";
  29.     cName       = "Gruppe";
  30.     cKaputt1    = "Kaputt";
  31.     cKaputt2    = "#  (%)";
  32.     cTotalDel1  = "Total";
  33.     cTotalDel2  = "#  (%)";
  34.     cPartDel1   = "Teil";
  35.     cPartDel2   = "#  (%)";
  36.     cPreMsg1    = "Messages";
  37.     cPreMsg2    = "vorher";
  38.     cPostMsg1   = "Messages";
  39.     cPostMsg2   = "nachher";
  40.     cPreBytes1  = "Gr”že";
  41.     cPreBytes2  = "vorher";
  42.     cPostBytes1 = "Gr”že";
  43.     cPostBytes2 = "nachher";
  44.     cDelBytes1  = "Bytes";
  45.     cDelBytes2  = "gel”scht";
  46.  
  47.     cFormatLine = "DisplayFormat";
  48.     
  49. TYPE
  50.      partNameType = (pGroup, pBadDel, pTotalDel, pPartDel, 
  51.                      pPreMsgs, pPostMsgs, pPreBytes, pPostBytes,
  52.                      pDelBytes); 
  53.      
  54.      partFormat = ARRAY [0..partFormatLength-1] OF CHAR;
  55.      
  56.      partType   = RECORD
  57.                     type        : partNameType;
  58.                     w           : INTEGER;
  59.                     formatStr   : partFormat;
  60.                   END;
  61.      partArrayType = ARRAY [0..maxParts-1] OF partType;
  62.      partArrayDesc = RECORD
  63.                        lines : INTEGER;
  64.                        width : INTEGER;
  65.                        maxNameWidth : INTEGER;
  66.                        parts : partArrayType;
  67.                      END;
  68.  
  69. VAR     listParts   : partArrayDesc;
  70.  
  71.  
  72. PROCEDURE GetPartCount(): INTEGER;
  73. BEGIN
  74.   RETURN listParts.lines-1;
  75. END GetPartCount;
  76.  
  77. PROCEDURE GetMaxLineWidth(): INTEGER;
  78.   VAR width : INTEGER;
  79.       i     : INTEGER;
  80. BEGIN
  81.   width := 0;
  82.   FOR i := 0 TO listParts.lines-1 DO
  83.     INC (width, GetPartWidth (i));
  84.   END;
  85.   RETURN width;
  86. END GetMaxLineWidth;
  87.  
  88. PROCEDURE GetPartWidth (part: INTEGER): INTEGER;
  89. BEGIN
  90.   IF (listParts.parts[part].type = pGroup)
  91.    & (listParts.parts[part].w = -1)
  92.   THEN
  93.     (* Maximale L„nge eines Gruppennamens zurckgeben *)
  94.     RETURN listParts.maxNameWidth;
  95.   END;
  96.   RETURN listParts.parts[part].w;
  97. END GetPartWidth;
  98.  
  99. PROCEDURE GetPartType (part: INTEGER): partNameType;
  100. BEGIN
  101.   RETURN listParts.parts[part].type;
  102. END GetPartType;
  103.  
  104. PROCEDURE ExtendStr (VAR str : ARRAY OF CHAR; l : CARDINAL; just: TextJustification);
  105.   VAR (*$Reg *) c : CARDINAL;
  106.       f1, f2: CARDINAL;
  107. BEGIN
  108.   c := LENGTH (str);
  109.   IF c < l
  110.   THEN
  111.     IF just = justLeft
  112.     THEN
  113.       MagicStrings.Append (Strings.Space (l-c), str);
  114.     ELSIF just = justCenter
  115.     THEN
  116.       f1 := (l - c) DIV 2;
  117.       f2 := (l - c) - f1;
  118.       MagicStrings.Insert (Strings.Space (f1), str, 0);
  119.       MagicStrings.Append (Strings.Space (f2), str);
  120.     ELSE
  121.       MagicStrings.Insert (Strings.Space (l-c), str, 0);
  122.     END;
  123.   END;
  124. END ExtendStr;
  125.  
  126. PROCEDURE CalcPercent (org, remain : LONGCARD) : LONGCARD;
  127.   VAR fOrg, fRem, tmp,
  128.       percent : LONGREAL;
  129. BEGIN
  130.   IF (org = 0) OR (remain = 0) THEN RETURN 0 END;
  131.   fOrg := LFLOAT (org);
  132.   fRem := LFLOAT (remain);
  133.   percent := 100.0 / (fOrg / fRem);
  134.   RETURN TRUNC (percent)
  135. END CalcPercent;
  136.  
  137. PROCEDURE CalcKiloBytes (theNumber : LONGCARD) : LONGCARD;
  138.   VAR kB : LONGCARD;
  139. BEGIN
  140.   kB := theNumber DIV 1024L;
  141.   IF theNumber MOD 1024L # 0 THEN INC (kB) END;
  142.   RETURN kB
  143. END CalcKiloBytes;
  144.  
  145. PROCEDURE FormatNumber (num1, num2: LONGCARD; width: CARDINAL;
  146.                         VAR str: ARRAY OF CHAR);
  147.  VAR tmpStr   : ARRAY [0..255] OF CHAR;
  148.      perStr   : ARRAY [0..255] OF CHAR;
  149. BEGIN
  150.   MagicStrings.Assign (CardToStr (num1, 0), tmpStr);
  151.   MagicStrings.Assign (" (", perStr);
  152.   MagicStrings.Append (CardToStr(CalcPercent (num2, num1), 2), perStr);
  153.   MagicStrings.Append ("%)", perStr);
  154.   MagicStrings.Assign (tmpStr, str);
  155.   IF LENGTH (tmpStr) + LENGTH (perStr) <= width
  156.   THEN
  157.     MagicStrings.Append (perStr, str);
  158.   END;
  159. END FormatNumber;
  160.  
  161. PROCEDURE GetPartJustification (ptr: ptrDispEntry; part: INTEGER): TextJustification;
  162. BEGIN
  163.   IF GetPartType (part) = pGroup
  164.   THEN
  165.     RETURN justLeft; 
  166.   ELSE
  167.     IF ptr^.type = dataEntry
  168.     THEN
  169.       RETURN justRight;
  170.     ELSE
  171.       RETURN justCenter;
  172.     END;
  173.   END;
  174. END GetPartJustification;
  175.  
  176. PROCEDURE GetPart (ptr: ptrDispEntry; part: INTEGER; 
  177.                    VAR str: ARRAY OF CHAR; fillUp: BOOLEAN);
  178.   VAR maxWidth : INTEGER;
  179.       tmpStr   : ARRAY [0..255] OF CHAR;
  180.       dataPtr  : ptrGrEntry;
  181.       just     : TextJustification;
  182. BEGIN
  183.   MagicStrings.Assign ("", str);
  184.   maxWidth := GetPartWidth (part);
  185.   dataPtr := ptr^.data;
  186.   CASE GetPartType (part) OF
  187.     pGroup      : 
  188.       IF ptr^.type = listHead1
  189.       THEN
  190.         MagicStrings.Copy (cName, 0, maxWidth, str);
  191.       ELSIF ptr^.type = dataEntry
  192.       THEN
  193.         IF dataPtr^.info = NIL
  194.         THEN
  195.           MagicStrings.Copy (cTotal, 0, maxWidth, str);
  196.         ELSE
  197.           MagicStrings.Copy (dataPtr^.info^.name^, 0, maxWidth, str);
  198.         END;
  199.       END; |
  200.     pBadDel     : 
  201.       IF ptr^.type = listHead1
  202.       THEN
  203.         MagicStrings.Copy (cKaputt1, 0, maxWidth, str);
  204.       ELSIF ptr^.type = listHead2
  205.       THEN
  206.         MagicStrings.Copy (cKaputt2, 0, maxWidth, str);
  207.       ELSIF ptr^.type = dataEntry
  208.       THEN
  209.         FormatNumber (dataPtr^.badDel, dataPtr^.preMsgs, maxWidth, str);
  210.       END; |
  211.     pTotalDel   :  
  212.       IF ptr^.type = listHead1
  213.       THEN
  214.         MagicStrings.Copy (cTotalDel1, 0, maxWidth, str);
  215.       ELSIF ptr^.type = listHead2
  216.       THEN
  217.         MagicStrings.Copy (cTotalDel2, 0, maxWidth, str);
  218.       ELSIF ptr^.type = dataEntry
  219.       THEN
  220.         FormatNumber (dataPtr^.totalDel, dataPtr^.preMsgs, maxWidth, str);
  221.       END; |
  222.     pPartDel    :  
  223.       IF ptr^.type = listHead1
  224.       THEN
  225.         MagicStrings.Copy (cPartDel1, 0, maxWidth, str);
  226.       ELSIF ptr^.type = listHead2
  227.       THEN
  228.         MagicStrings.Copy (cPartDel2, 0, maxWidth, str);
  229.       ELSIF ptr^.type = dataEntry
  230.       THEN
  231.         FormatNumber (dataPtr^.partDel, dataPtr^.preMsgs, maxWidth, str);
  232.       END; |
  233.     pPreMsgs    :  
  234.       IF ptr^.type = listHead1
  235.       THEN
  236.         MagicStrings.Copy (cPreMsg1, 0, maxWidth, str);
  237.       ELSIF ptr^.type = listHead2
  238.       THEN
  239.         MagicStrings.Copy (cPreMsg2, 0, maxWidth, str);
  240.       ELSIF ptr^.type = dataEntry
  241.       THEN
  242.         MagicStrings.Assign (CardToStr (dataPtr^.preMsgs,0), str);
  243.       END; |
  244.     pPostMsgs   :  
  245.       IF ptr^.type = listHead1
  246.       THEN
  247.         MagicStrings.Copy (cPostMsg1, 0, maxWidth, str);
  248.       ELSIF ptr^.type = listHead2
  249.       THEN
  250.         MagicStrings.Copy (cPostMsg2, 0, maxWidth, str);
  251.       ELSIF ptr^.type = dataEntry
  252.       THEN
  253.         MagicStrings.Assign (CardToStr (dataPtr^.postMsgs,0), str);
  254.       END; |
  255.     pPreBytes   :  
  256.       IF ptr^.type = listHead1
  257.       THEN
  258.         MagicStrings.Copy (cPreBytes1, 0, maxWidth, str);
  259.       ELSIF ptr^.type = listHead2
  260.       THEN
  261.         MagicStrings.Copy (cPreBytes2, 0, maxWidth, str);
  262.       ELSIF ptr^.type = dataEntry
  263.       THEN
  264.         MagicStrings.Assign (CardToStr (CalcKiloBytes(dataPtr^.preBytes),0), str);
  265.         MagicStrings.Append (" KB", str);
  266.       END; |
  267.     pPostBytes  : 
  268.       IF ptr^.type = listHead1
  269.       THEN
  270.         MagicStrings.Copy (cPostBytes1, 0, maxWidth, str);
  271.       ELSIF ptr^.type = listHead2
  272.       THEN
  273.         MagicStrings.Copy (cPostBytes2, 0, maxWidth, str);
  274.       ELSIF ptr^.type = dataEntry
  275.       THEN
  276.         MagicStrings.Assign (CardToStr (CalcKiloBytes(dataPtr^.postBytes),0), str);
  277.         MagicStrings.Append (" KB", str);
  278.       END; |
  279.     pDelBytes   :
  280.       IF ptr^.type = listHead1
  281.       THEN
  282.         MagicStrings.Copy (cDelBytes1, 0, maxWidth, str);
  283.       ELSIF ptr^.type = listHead2
  284.       THEN
  285.         MagicStrings.Copy (cDelBytes2, 0, maxWidth, str);
  286.       ELSIF ptr^.type = dataEntry
  287.       THEN
  288.         IF (dataPtr^.postBytes > 0) & (dataPtr^.preBytes >= dataPtr^.postBytes) 
  289.         THEN
  290.           MagicStrings.Assign (CardToStr (CalcKiloBytes(dataPtr^.preBytes - dataPtr^.postBytes),0), str);
  291.         ELSE
  292.           MagicStrings.Assign ("0", str);
  293.         END;
  294.         MagicStrings.Append (" KB", str);
  295.       END; |
  296.   ELSE
  297.   END;
  298.   IF fillUp
  299.   THEN
  300.     ExtendStr (str, maxWidth, GetPartJustification (ptr, part))
  301.   END;
  302. END GetPart;
  303.  
  304. PROCEDURE SetMaxNameLength (maxLen : INTEGER);
  305. BEGIN
  306.   listParts.maxNameWidth := maxLen;
  307. END SetMaxNameLength;
  308.  
  309. PROCEDURE parseFormatLine (REF listline : ARRAY OF CHAR; onlyTest : BOOLEAN) : BOOLEAN; 
  310. TYPE charSet = SET OF CHAR;
  311. CONST okSet = charSet{'B','D', 'G', 'M', 'N', 'T', 'V', 'W', 'X'};
  312.      numSet = charSet{'-','0'..'9'};
  313.      skipSet = charSet{' ',','};
  314.      formatSet = charSet{};
  315.   VAR p : partArrayDesc;
  316.       num : LONGINT;
  317.       ch  : CHAR;
  318.       z, l: CARDINAL;
  319.       pName : partNameType;
  320.       fStr  : partFormat;
  321.       i     : INTEGER;
  322.       negative: BOOLEAN;
  323.       pos   : CARDINAL;
  324.       numStr: MaxStr;
  325. BEGIN 
  326.   l := LENGTH (listline);
  327.   IF l = 0 THEN RETURN FALSE END;
  328.   z := 0;
  329.   p.lines := 0;
  330.   p.width := 0;
  331.   WHILE z < l DO
  332.     (* Ersten Eintrag suchen *)
  333.     WHILE (z < l) & (listline[z] IN skipSet) DO INC (z) END;
  334.     IF z < l
  335.     THEN
  336.       ch := listline[z];
  337.       FOR i := 0 TO partFormatLength-1 DO fStr[i] := 0C; END;
  338.       IF (listline[z+1] # '(') THEN RETURN FALSE END;
  339.       INC (z,2);        (* z+1 = '(' *)
  340.       num := 0;
  341.       i := 0;
  342.       WHILE (listline [z] IN numSet) & (z < l) DO 
  343.         numStr[i] := listline[z];
  344.         INC (i);
  345.         (* num := num * 10 + LONG(ORD (listline[z]) - ORD('0')); *)
  346.         INC(z); 
  347.       END;
  348.       numStr[i] := '';
  349.       pos := 0;
  350.       num := StrToLInt (numStr, pos, v.bool);
  351.       IF (z >= l) OR 
  352.          ( (listline[z] # ')') &
  353.            ( (listline[z] # ',') & ~(ch IN formatSet))
  354.          )
  355.       THEN 
  356.         RETURN FALSE 
  357.       END;
  358.       IF (listline[z] = ',') & (ch IN formatSet)
  359.       THEN
  360.         (* Formatstring lesen *)
  361.         INC (z);    (* ',' berspringen *)
  362.         i := 0;
  363.         WHILE (listline[z] # ')') & (z < l) & (i < partFormatLength) DO
  364.           fStr[i] := listline[z];
  365.           INC (z); INC (i);
  366.         END;
  367.         IF (i >= partFormatLength) OR (z >= l) THEN RETURN FALSE END; 
  368.       END;
  369.       INC(z);   (* ')' berspringen *)
  370.       CASE ch OF
  371.         'B' : pName := pBadDel;   |
  372.         'D' : pName := pTotalDel; |
  373.         'G' : pName := pGroup;    |
  374.         'M' : pName := pPreMsgs;  |
  375.         'N' : pName := pPostMsgs; |
  376.         'T' : pName := pPartDel;  |
  377.         'V' : pName := pPreBytes; |
  378.         'W' : pName := pPostBytes; |
  379.         'X' : pName := pDelBytes; |
  380.       ELSE
  381.         RETURN FALSE;
  382.       END;
  383.       IF (num = 0) OR (num > 1024) THEN RETURN FALSE END;
  384.       p.parts[p.lines] := partType{pName, INTEGER(SHORT(num)), fStr}; 
  385.       INC (p.lines);
  386.       INC (p.width, num);
  387.     END;
  388.   END;
  389.   IF p.lines = 0
  390.   THEN 
  391.     RETURN FALSE 
  392.   END;
  393.   IF onlyTest THEN RETURN TRUE END;
  394.   v.bool := ConfVars.SetConfigString (cFormatLine, listline);
  395.   listParts := p;
  396.   RETURN TRUE;
  397. END parseFormatLine;
  398.  
  399. PROCEDURE ParseFormat (REF format: ARRAY OF CHAR);
  400. BEGIN
  401.   v.bool := parseFormatLine (format, FALSE);
  402. END ParseFormat;
  403.  
  404. PROCEDURE CheckFormatLine (REF listline : ARRAY OF CHAR): BOOLEAN; 
  405.   (* Das Format einer Zeile besteht aus einzelnen Krzeln 
  406.    * fr einen Eintrag und darauffolgend in Klammern die Weite dieses Eintrages.
  407.    * Beispiel: D(12),I(10),U(30),W(30),F(2)
  408.    * Erlaubte Zeilenelemente:
  409.    * G: Gruppe. Bei einer Weite von -1 wird die L„nge des l„ngsten Namens 
  410.    *    genommen
  411.    * B: Anzahl besch„digte Nachrichten
  412.    * D: Anzahl totalgel”schter Nachrichten 
  413.    * T: Anzahl teilgel”schter Nachrichten
  414.    * M: Anzahl Nachrichten vorher
  415.    * N: Anzahl Nachrichten nachher
  416.    * V: Kilobytes vorher
  417.    * W: Kilobytes nachher
  418.    * X: Kilobytes gel”scht
  419.    *)
  420. BEGIN
  421.   RETURN parseFormatLine (listline, TRUE);
  422. END CheckFormatLine;
  423.  
  424. PROCEDURE InitFormat();
  425.   VAR str   : ARRAY [0..255] OF CHAR;
  426. BEGIN
  427.   IF ~ConfVars.GetConfigString (cFormatLine, str)
  428.   THEN
  429.     MagicStrings.Assign ("G(-1),M(12),V(10),D(12),T(12),B(12),N(12),W(10),X(10)", str);
  430.   END;
  431.   ParseFormat (str);
  432. END InitFormat;
  433.  
  434. END PutzList.
  435.